package com.iris.live.services.common;

import com.iris.live.services.vo.ReportVO;
import org.slf4j.LoggerFactory;

import java.text.DecimalFormat;
import java.util.*;

/**
 * 报表工具类
 */
public class ReportUtils {

    private static org.slf4j.Logger logger = LoggerFactory.getLogger(ReportUtils.class);
    private static DecimalFormat df_2 = new DecimalFormat("0.00");

    /**
     * 构造区域合计区合计变为map存入sql运行出的List中     运行顺序最先
     *
     * @param data
     * @return
     */
    public static List<ReportVO> getAreaData(List<Map<ParameterName, Double>> data) {
        //集团求和另外取，此处只算一次求和
        for (Map<ParameterName, Double> areaInfo : data) {

        }
        return null;
    }

    /**
     * 构造品牌合计基础的数据  将品牌 合计变为map存入sql运行出的List中       组织架构品牌分组
     *
     * @param data
     * @param brandInfo 品牌列表  用'|'做分隔  默认
     * @return
     */
    public static void getBrandData(List<Map<ParameterName, Object>> data, String brandInfo) {
        String[] brandList = null;//品牌分隔数组   MM+MM  ,MM+AMG
        if (brandInfo != null) {
            brandList = brandInfo.split("|");
        }// MM+MB|MM+AMG  变成了  {MM+MB,MM+AMG}
        if (brandList == null) {
            logger.debug("没有品牌组数据新增");
        } else {
            List<Map<ParameterName, Object>> newDataList = new ArrayList<>();//;数据
            //执行品牌合计操作
            for (String brandGroup : brandList) {
                String[] brandNameLists = brandGroup.split("\\+"); //MM+AMG   变成{MM,AMG}
                Map brandMap = new HashMap();
                for (String item : brandNameLists) { //循环品牌  构造MAP  便于后面判断
                    brandMap.put(item, "");
                }
                Map<String, Map<ParameterName, Object>> brandGroupData = new HashMap<>();
                for (Map<ParameterName, Object> info : data) {//构造对应店名的新的数据集合
                    String a = info.get(ParameterName.许可).toString();
                    Map<ParameterName, Object> itData = new HashMap<>();
                    itData.put(ParameterName.许可, a);
                    itData.put(ParameterName.品牌, brandGroup);
                    brandGroupData.put(a, itData);
                }
                //  遍历查询数据集 先判断许可是否在新构造的数据集brandGround中， 存在则取出构造数据集 ；
                //判断品牌是否存在与品牌组数据集中，存在则取出 查询数据集数据  与构造数据集做加法
                for (Map<ParameterName, Object> info : data) {//循环数据
                    if (brandGroupData.containsKey(info.get(ParameterName.许可).toString())) {//匹配店名
                        Map<ParameterName, Object> itData = brandGroupData.get(info.get(ParameterName.许可).toString());
                        String brandA = info.get(ParameterName.品牌).toString();
                        if (brandMap.containsKey(brandA)) {
                            //做数据相加操作
                            addData(info,itData);
                        }
                    }
                    for (Map.Entry<String, Map<ParameterName, Object>> entry : brandGroupData.entrySet()) {
                        newDataList.add(entry.getValue());
                    }
                }
            }
            data.addAll(newDataList);
        }

    }


    /**
     * 构造销售相关的返回数据
     *
     * @param data
     * @return
     */
    public static List<ReportVO> getVolumeData(Map<ParameterName, Double> data) {
        return null;
    }

    /**
     * 构造库存相关的返回数据
     *
     * @param data
     * @return
     */
    public static List<ReportVO> getClosingStockData(Map<ParameterName, Double> data) {
        return null;
    }

    /**
     * 构造财务相关的返回数据
     *
     * @param data
     * @return
     */
    public static List<ReportVO> getFinanceData(Map<ParameterName, Double> data) {
        return null;
    }

    /**
     * 构造库存相关的返回数据
     *
     * @param data
     * @return
     */
    public static List<ReportVO> getOtherIncomeData(Map<ParameterName, Double> data) {
        return null;
    }

    /**
     * 构造生产力相关的返回数据
     *
     * @param data
     * @return
     */
    public static List<ReportVO> getSalesProductivityIncomeData(Map<ParameterName, Double> data) {
        return null;
    }

    /**
     *  进行加法运算 将新构造的数据基础上加上 查出的数据  组成新数据
     * @param infoData 查出的数据
     * @param newData 新构造的数据
     */
    private static void addData( Map<ParameterName, Object> infoData, Map<ParameterName, Object> newData){

    }

    private static double toDouble(Map<GPUtils.ParameterName, Double> data, GPUtils.ParameterName column) {
        return toDouble(data, column, 0);
    }

    private static double toDouble(Map<GPUtils.ParameterName, Double> data, GPUtils.ParameterName column, double defaultValue) {
        if (!data.containsKey(column)) {
            logger.warn("No column found for " + column.name());

            return defaultValue;
        }

        try {
            Double value = data.get(column);
            if (value == null || Double.isNaN(value) || Double.isInfinite(value)) {
                if (logger.isDebugEnabled()) {
                    logger.debug("invalid value is for column = " + column + ", value=" + value);
                }

                return defaultValue;
            }

            return value;
        } catch (Exception exc) {
            logger.error("参数名=" + column.name(), exc);

            return defaultValue;
        }
    }



    public static Map setDateSection  (Map info)throws Exception {
        //如果查询月份和年不为空，则构造 指定月和年区间 ，用于组织架构维度
        Integer year=null,quarter=null,month=null;
        String selectValue = info.get("selectYear") == null ? "all" : info.get("selectYear").toString();
        if(! (StringUtils.isNullOrBlank(selectValue) || "all".equalsIgnoreCase(selectValue) || "全部".equalsIgnoreCase(selectValue))){
            year=Integer.parseInt(selectValue);
        }

        selectValue = info.get("selQuarter") == null ? "all" : info.get("selQuarter").toString();
        if(! (StringUtils.isNullOrBlank(selectValue) || "all".equalsIgnoreCase(selectValue) || "全部".equalsIgnoreCase(selectValue))){
            quarter=Integer.parseInt(selectValue);
        }

        selectValue = info.get("selMonth") == null ? "all" : info.get("selMonth").toString();
        if(! (StringUtils.isNullOrBlank(selectValue) || "all".equalsIgnoreCase(selectValue) || "全部".equalsIgnoreCase(selectValue))){
            if(selectValue.endsWith("月")){
                selectValue = selectValue.substring(0, selectValue.indexOf("月"));
            }
            month=Integer.parseInt(selectValue) - 1;
        }
        //如果年月不为空 则指定月
        if(month!=null&&year!=null){
            info.put("startDay",(getFirstDayOfMonth(year,month)));
            info.put("endDay",(getLastDayOfMonth(year,month)));
            return info;
        }
        if (quarter!=null&&year!=null){
            info.put("startDay",(getFirstDayOfQuarter(year,quarter)));
            info.put("endDay",(getLastDayOfQuarter(year,quarter)));
            return info;
        }
        if(year!=null){
            info.put("startDay",(getCurrYearFirst(year)));
            info.put("endDay",(getCurrYearLast(year)));
            return info;
        }
        return info;
    }


    /**
     * 返回指定年月的月的第一天
     *
     * @param year
     * @param month
     * @return
     */
    public static String getFirstDayOfMonth(Integer year, Integer month)throws Exception {
        Calendar calendar = Calendar.getInstance();
        if (year == null) {
            year = calendar.get(Calendar.YEAR);
        }
        if (month == null) {
            month = calendar.get(Calendar.MONTH);
        }
        calendar.set(year, month, 1);
        return DateUtils.format(calendar.getTime(),DateUtils.SIMPLE_FORMAT);
    }
    /**
     * 返回指定年月的月的最后一天
     *
     * @param year
     * @param month
     * @return
     */
    public static String getLastDayOfMonth(Integer year, Integer month) throws Exception {
        Calendar calendar = Calendar.getInstance();
        if (year == null) {
            year = calendar.get(Calendar.YEAR);
        }
        if (month == null) {
            month = calendar.get(Calendar.MONTH);
        }
        calendar.set(year, month, 1);
        calendar.roll(Calendar.DATE, -1);
        return DateUtils.format(calendar.getTime(),DateUtils.SIMPLE_FORMAT);
    }
    /**
     * 返回指定年季的季的第一天
     *
     * @param year
     * @param quarter
     * @return
     */
    public static String getFirstDayOfQuarter(Integer year, Integer quarter)throws Exception {
        Calendar calendar = Calendar.getInstance();
        Integer month = new Integer(0);
        if (quarter == 1) {
            month = 1 - 1;
        } else if (quarter == 2) {
            month = 4 - 1;
        } else if (quarter == 3) {
            month = 7 - 1;
        } else if (quarter == 4) {
            month = 10 - 1;
        } else {
            month = calendar.get(Calendar.MONTH);
        }
        return getFirstDayOfMonth(year, month);
    }
    /**
     * 返回指定年季的季的最后一天
     *
     * @param year
     * @param quarter
     * @return
     */
    public static String getLastDayOfQuarter(Integer year, Integer quarter) throws Exception {
        Calendar calendar = Calendar.getInstance();
        Integer month = new Integer(0);
        if (quarter == 1) {
            month = 3 - 1;
        } else if (quarter == 2) {
            month = 6 - 1;
        } else if (quarter == 3) {
            month = 9 - 1;
        } else if (quarter == 4) {
            month = 12 - 1;
        } else {
            month = calendar.get(Calendar.MONTH);
        }
        return getLastDayOfMonth(year, month);
    }
    /**
     * 获取某年第一天日期
     * @param year 年份
     * @return Date
     */
    public static String getCurrYearFirst(int year)throws Exception {
        Calendar calendar = Calendar.getInstance();
        calendar.clear();
        calendar.set(Calendar.YEAR, year);
        return DateUtils.format(calendar.getTime(),DateUtils.SIMPLE_FORMAT);
    }

    /**
     * 获取某年最后一天日期
     * @param year 年份
     * @return Date
     */
    public static String getCurrYearLast(int year)throws Exception {
        Calendar calendar = Calendar.getInstance();
        calendar.clear();
        calendar.set(Calendar.YEAR, year);
        calendar.roll(Calendar.DAY_OF_YEAR, -1);
        return DateUtils.format(calendar.getTime(),DateUtils.SIMPLE_FORMAT);
    }
    public enum ParameterName {
        集团,许可,许可_BMBS,经销商名,经销商名_EN,大区,大区_EN,小区,小区_EN,CTA,CTA_EN,
        SalesCode,来源,品牌,级别,
        车辆销售价, 车辆购置税, 车辆消费税, 商业险保费, 交强险保费, 交强险手续费, 商业手续费,
        车船税, 精品销售价格, 上牌服务费, 加配价格, 玻璃维修服务费, gps服务费, 盗抢险, 第三方延保,
        厂家延保, 二手车置换费用, 金融服务费, 其他服务费, 其他一, 其他二, 其他三, 其他四, 其他五,
        采购价毛利不含税, 预估返利, 预估返利毛利, 保险毛利不含税, 精品毛利不含税, 上牌毛利不含税,
        玻璃维修毛利不含税, GPS毛利不含税, 盗抢险毛利不含税, 第三方延保毛利不含税, 厂家延保毛利不含税,
        金融服务费毛利, 其他服务费毛利, 其他一毛利, 其他二毛利, 其他三毛利, 其他四毛利, 其他五毛利, 综合毛利,
        库存库龄一, 库存库龄二, 库存库龄三, 库存库龄四, 库存库龄五, 库存库龄六
    }
}
